home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / listings / v_08_09 / 8n09083a < prev    next >
Encoding:
Text File  |  1990-05-30  |  12.9 KB  |  584 lines
  1. /*
  2.      +--------------------------------------------------------------+
  3.      |    @(#) bfs_cmon.c   v1.0   90/04/02                           |
  4.      |                                                              |
  5.      |  Copyright (C) 1990, StonyBrook Technologies, Inc.,          |
  6.      |  All Rights Reserved.                                        |
  7.      |                                                              |
  8.      |  This Module contains Proprietary Information of             |
  9.      |  StonyBrook Technologies, Inc. and should be treated         |
  10.      |  as Confidential.                                            |
  11.      |                                                              |
  12.      +--------------------------------------------------------------+
  13.  
  14.      bfs_cmon.c - this is a client server daemon.
  15.  
  16. */
  17.  
  18. #include <stdio.h>
  19. #include <sys/fcntl.h>
  20. #include <sys/types.h>
  21. #include <sys/stat.h>
  22. #include <errno.h>
  23. #include <sys/signal.h>
  24. #include <varargs.h>
  25. #include <eicon/x25.h>
  26. #include "bfs.h"
  27.  
  28. static int running = 1;  /* running bit - can be modified on SIGINT */
  29.  
  30. char    cname[16];        /* client name */
  31. char    laddr[16];          /* client addr */
  32. int     cfifo;              /* client fifo */
  33.  
  34. int    c_lcb_cnt = 0;      /* line cntl blk count */
  35. C_LCB    c_lcb[MAX_C_LCB];   /* line cntl blk       */
  36.  
  37. C_FCB   c_fcb[MAX_C_FCB];   /* apl fifo cntl blk   */
  38. C_SCB   c_scb[MAX_C_SCB];   /* session cntl blk    */
  39.  
  40. /* x.25 call parameter data */
  41. struct x25parm x25_parms = { 0, "", 0, "", "" };
  42.  
  43. /* debug stuff */
  44. int cmon_io;
  45. char cmon_buf[132];
  46. int debug_flag = 0;
  47.  
  48.  
  49. signal_trap(in_signal)
  50. int in_signal;
  51. {
  52.   if(in_signal == SIGTERM) 
  53.     running = 0;   /* terminate when requested by outside */
  54. }
  55.  
  56. cleanup_exit(exval)
  57. int exval;
  58. {
  59.   cmon_term();
  60.   exit(exval);
  61. }
  62.  
  63. cmon_init()
  64. {
  65.   FILE *ifd;
  66.   char buf[132];
  67.   int i, foundme;
  68.  
  69.   dopen();
  70.  
  71.   for(i=0; i<MAX_C_LCB; i++) {
  72.     c_lcb[i].port = c_lcb[i].link = c_lcb[i].cid = 0;
  73.     c_lcb[i].sname[0] = '\0';
  74.     c_lcb[i].raddr[0] = '\0';
  75.     c_lcb[i].cbuf = c_lcb[i].rbuf = NULL;
  76.   }
  77.  
  78.   for(i=0; i<MAX_C_FCB; i++) 
  79.     c_fcb[i].afifo = c_fcb[i].pid = c_fcb[i].link = 0;
  80.  
  81.   for(i=0; i<MAX_C_SCB; i++) {
  82.     c_scb[i].pid = c_scb[i].fid =
  83.       c_scb[i].lid = c_scb[i].ssid = 0;
  84.     c_scb[i].state = -1;
  85.   }
  86.  
  87.   c_lcb_cnt = 0;
  88.   foundme = 0;
  89.  
  90.   if((ifd=fopen("servers", "r")) != NULL) {
  91.     while(fgets(buf, 132, ifd)) {
  92.       if((buf[0] != '#') && (sscanf(buf, "%s %d %s",
  93.           c_lcb[c_lcb_cnt].sname,
  94.           &c_lcb[c_lcb_cnt].port,
  95.           c_lcb[c_lcb_cnt].raddr) > 0)) {
  96.         if(!foundme) {
  97.           foundme = 1;
  98.           strcpy(cname, c_lcb[c_lcb_cnt].sname);
  99.           strcpy(laddr, c_lcb[c_lcb_cnt].raddr);
  100.         } else
  101.           c_lcb_cnt++;
  102.       }
  103.     }
  104.     fclose(ifd);
  105.   } else {
  106.     strcpy(cname, "NONAMECLIENT");
  107.     strcpy(laddr, "12345");
  108.   }
  109.  
  110.   cfifo_init();
  111.   cx25_init(); 
  112. }
  113.  
  114. cmon_term()
  115. {
  116.   cfifo_term();
  117.   cx25_term();
  118.   dprintf("BFS-CMON Terminating\n");
  119.   dclose();
  120. }
  121.  
  122.  
  123. main()
  124. {
  125.   RPC_MSG rpc_msg;
  126.   int flags;
  127.  
  128.   cmon_init();
  129.  
  130.   dprintf("Basic File System - Client Monitor (BFS-CMON) Ver 1.0\n");
  131.   dprintf("Copyright (C) 1990, StonyBrook Technologies, Inc.\n");
  132.   dprintf("All Rights Reserved.\n");
  133.  
  134.   print_info();  /* print routing table to debug file */
  135.  
  136.   if(signal(SIGTERM, signal_trap) == -1) {   /* setup signal handler */
  137.     perror("SIGTERM Failed");
  138.     exit(errno);
  139.   }
  140.  
  141.   while( running ) {
  142.     if(cfifo_read(&rpc_msg, sizeof(RPC_MSG))) {
  143.       switch(rpc_msg.hdr.code) {
  144.         case RPC_FOPEN_CMD:
  145.           cmon_fopen(&rpc_msg);
  146.           break;
  147.         case RPC_FCLOSE_CMD:
  148.           cmon_fclose(&rpc_msg);
  149.           break;
  150.         case RPC_FWRITE_CMD:
  151.           cmon_fwrite(&rpc_msg);
  152.           break;
  153.         case RPC_FREAD_CMD:
  154.           cmon_fread(&rpc_msg);
  155.           break;
  156.         case RPC_FEOF_CMD:
  157.           cmon_feof(&rpc_msg);
  158.           break;
  159.         default:
  160.           break;
  161.       }
  162.     }
  163.   }
  164.  
  165.   cmon_term();
  166. }
  167.  
  168.  
  169. /* cfifo_init, _term, _open, _close, _read, _write routines */
  170.  
  171. cfifo_init()
  172. {
  173.   int flags;
  174.  
  175.   if(mknod("/tmp/CFIFO", S_IFIFO|0666, 0) == -1) return(0);
  176.  
  177.   if((cfifo=open("/tmp/CFIFO", O_RDONLY|O_NDELAY)) != -1) {
  178.     flags = fcntl(cfifo, F_GETFL, &flags);
  179.     flags &= ~O_NDELAY;
  180.     fcntl(cfifo, F_SETFL, &flags);
  181.     return(1);
  182.   } 
  183.   unlink("/tmp/CFIFO");
  184.   return(0);
  185. }
  186.  
  187. cfifo_term()
  188. {
  189.   close(cfifo);
  190.   unlink("/tmp/CFIFO");
  191. }
  192.  
  193.  
  194. cfifo_open(pid)
  195. int pid;
  196. {
  197.   int i;
  198.   for(i=0; i<MAX_C_FCB; i++)
  199.     if((c_fcb[i].link) && (c_fcb[i].pid == pid)) {
  200.       c_fcb[i].link++;
  201.       return(1);
  202.     }
  203.   for(i=0; i<MAX_C_FCB; i++)
  204.     if(!c_fcb[i].link) {
  205.       sprintf(c_fcb[i].afname, "/tmp/AFIFO.%d", pid);
  206.       if((c_fcb[i].afifo=open(c_fcb[i].afname, O_WRONLY)) != -1) {
  207.         c_fcb[i].link = 1;
  208.         c_fcb[i].pid = pid;
  209.         return(1);
  210.       } 
  211.       break;
  212.     }
  213.   return(0);
  214. }
  215.  
  216.  
  217. cfifo_close(pid)
  218. int pid;
  219. {
  220.   int i;
  221.  
  222.   for(i=0; i<MAX_C_FCB; i++)
  223.     if(c_fcb[i].pid == pid) {
  224.       c_fcb[i].link--;
  225.       if(!c_fcb[i].link) {
  226.         close(c_fcb[i].afifo);
  227.         c_fcb[i].pid = c_fcb[i].afifo = -1;
  228.       }
  229.     return(1);    
  230.     }
  231.   return(0);    
  232. }
  233.  
  234. cfifo_read(buf, cnt)
  235. char *buf;
  236. int cnt;
  237. {
  238.   return(read(cfifo, buf, cnt));
  239. }
  240.  
  241. cfifo_write(pid, buf, cnt)
  242. int pid, cnt;
  243. char *buf;
  244. {
  245.   int i;
  246.  
  247.   for(i=0; i<MAX_C_FCB; i++)
  248.     if(c_fcb[i].pid == pid)
  249.       return(write(c_fcb[i].afifo, buf, cnt));
  250.   return(0);
  251. }
  252.  
  253.  
  254. /* cx25_init, _term, _open, _close,
  255.        _send_cmd, _send_data, _recv_rsp, _recv_data */
  256.  
  257.  
  258. cx25_init()
  259. {
  260.   x25init(0); 
  261. }
  262.  
  263. cx25_term()
  264. {
  265.   x25exit(); 
  266. }
  267.  
  268. cx25_open(lid)
  269. int lid;
  270. {
  271.   if(!c_lcb[lid].link) {
  272.     dprintf("open x25 line %d\n", lid);
  273.     if(x25call(c_lcb[lid].raddr, laddr, &x25_parms,
  274.                c_lcb[lid].port, X25WAIT, &c_lcb[lid].cid) == -1) {
  275.       dprintf("x25 open error %d on line %d\n", x25error(), lid);
  276.       return(0);
  277.     }
  278.     dprintf("x25 line %d opened ok\n", lid);
  279.     c_lcb[lid].link = 1;
  280.     c_lcb[lid].cbuf = x25alloc(sizeof(RPC_FOPEN_CMD_MSG));
  281.     c_lcb[lid].rbuf = x25alloc(sizeof(RPC_FOPEN_RSP_MSG));
  282.   } else {
  283.     dprintf("link x25 line %d\n", lid);
  284.     c_lcb[lid].link++;
  285.   }
  286.   return(1);
  287. }
  288.  
  289. cx25_close(lid)
  290. int lid;
  291. {
  292.   dprintf("delink x25 line %d\n", lid);
  293.   c_lcb[lid].link--;
  294.   if(!c_lcb[lid].link) {
  295.     dprintf("close x25 line %d\n", lid);
  296.     x25free(c_lcb[lid].cbuf);
  297.     x25free(c_lcb[lid].rbuf);
  298.   }
  299.   return(1);
  300. }
  301.  
  302. cx25_send_cmd(lid, buf, cnt)
  303. int lid, cnt;
  304. char *buf;
  305. {
  306.   memcpy(c_lcb[lid].cbuf, buf, cnt);
  307.   cnt = x25send(c_lcb[lid].cid, c_lcb[lid].cbuf, cnt, 0);
  308.   return(cnt);
  309. }
  310.  
  311. cx25_send_data(lid, pid, cnt)
  312. int lid, pid, cnt;
  313. {
  314.   c_lcb[lid].dbuf = x25alloc(cnt);
  315.   cfifo_read(c_lcb[lid].dbuf, cnt);
  316.   cnt = x25send(c_lcb[lid].cid, c_lcb[lid].dbuf, cnt, 0); 
  317.   x25free(c_lcb[lid].dbuf);
  318.   return(cnt);
  319. }
  320.  
  321. cx25_recv_rsp(lid, buf, cnt)
  322. int lid, cnt;
  323. char *buf;
  324. {
  325.   cnt = x25recv(c_lcb[lid].cid, c_lcb[lid].cbuf, cnt, 0);
  326.   memcpy(buf, c_lcb[lid].cbuf, cnt);
  327.   return(cnt);
  328. }
  329.  
  330. cx25_recv_data(lid, pid, cnt)
  331. int lid, pid, cnt;
  332. {
  333.   c_lcb[lid].dbuf = x25alloc(cnt);
  334.   cnt = x25recv(c_lcb[lid].cid, c_lcb[lid].dbuf, cnt, 0); 
  335.   cfifo_write(pid, c_lcb[lid].dbuf, cnt);
  336.   x25free(c_lcb[lid].dbuf);
  337.   return(cnt);
  338. }
  339.  
  340.  
  341. /* cmon_fopen, _fclose, _fread, _fwrite, _feof routines */
  342.  
  343.  
  344. cmon_fopen(rpc_msg)
  345. RPC_MSG *rpc_msg;
  346. {
  347.   int pid, fid, lid, csid;
  348.   RPC_FOPEN_CMD_MSG focmd;
  349.   RPC_FOPEN_RSP_MSG forsp;
  350.  
  351.   cfifo_read(focmd.sname, rpc_msg->hdr.dlen);
  352.  
  353.   pid = rpc_msg->hdr.csid;
  354.   fid = rpc_msg->hdr.ssid;
  355.   lid = get_server_id(focmd.sname);
  356.  
  357.   if(cfifo_open(pid)) {
  358.     if(lid != -1 ) {
  359.       dprintf("fopen req for %s - ok\n", focmd.sname);
  360.       if(cx25_open(lid)) {
  361.         if((csid=allocate_csid(pid, fid, lid)) != -1) {
  362.           focmd.hdr.code = RPC_FOPEN_CMD;
  363.           focmd.hdr.csid = csid;
  364.           focmd.hdr.ssid = 0;
  365.           focmd.hdr.dlen = rpc_msg->hdr.dlen;
  366.           cx25_send_cmd(lid, (char *)&focmd, sizeof(RPC_FOPEN_CMD_MSG));
  367.           cx25_recv_rsp(lid, (char *)&forsp, sizeof(RPC_FOPEN_RSP_MSG));
  368.           forsp.hdr.csid = pid;
  369.           forsp.hdr.ssid = fid;
  370.           cfifo_write(pid, (char *)&forsp, sizeof(RPC_FOPEN_RSP_MSG)); 
  371.           if(forsp.status == -1) {
  372.             deallocate_csid(csid);
  373.             cx25_close(lid);
  374.             cfifo_close(pid);
  375.           }
  376.           return;
  377.         } else  
  378.           cx25_close(lid);
  379.       } 
  380.     } 
  381.     dprintf("fopen req for %s - failed\n", focmd.sname);
  382.     forsp.hdr.code = RPC_FOPEN_RSP;
  383.     forsp.hdr.csid = pid;
  384.     forsp.hdr.ssid = fid;
  385.     forsp.hdr.dlen = 0;
  386.     forsp.status = -1;
  387.     forsp.errno = ENONET;
  388.     cfifo_write(pid, (char *)&forsp, sizeof(RPC_FOPEN_RSP_MSG)); 
  389.     cfifo_close(pid);
  390.   }
  391. }
  392.  
  393. cmon_fclose(rpc_msg)
  394. RPC_MSG *rpc_msg;
  395. {
  396.   int pid, fid, lid, csid;
  397.   RPC_FCLOSE_CMD_MSG fccmd;
  398.   RPC_FCLOSE_RSP_MSG fcrsp;
  399.  
  400.   pid = rpc_msg->hdr.csid;
  401.   fid = rpc_msg->hdr.ssid;
  402.   if((csid = locate_csid(pid, fid)) == -1) return;
  403.   lid = c_scb[csid].lid;
  404.  
  405.   fccmd.hdr.code = RPC_FCLOSE_CMD;
  406.   fccmd.hdr.csid = csid;
  407.   fccmd.hdr.ssid = c_scb[csid].ssid;
  408.   fccmd.hdr.dlen = 0;
  409.   cx25_send_cmd(lid, (char *)&fccmd, sizeof(RPC_FCLOSE_CMD_MSG));
  410.   cx25_recv_rsp(lid, (char *)&fcrsp, sizeof(RPC_FCLOSE_RSP_MSG));
  411.   cfifo_write(pid, (char *)&fcrsp, sizeof(RPC_FCLOSE_RSP_MSG)); 
  412.   deallocate_csid(csid);
  413.   cfifo_close(pid);
  414.   cx25_close(lid);
  415. }
  416.  
  417. cmon_fread(rpc_msg)
  418. RPC_MSG *rpc_msg;
  419. {
  420.   int pid, fid, lid, csid;
  421.   RPC_FREAD_CMD_MSG frcmd;
  422.   RPC_FREAD_RSP_MSG frrsp;
  423.  
  424.   pid = rpc_msg->hdr.csid;
  425.   fid = rpc_msg->hdr.ssid;
  426.   if((csid = locate_csid(pid, fid)) == -1) return;
  427.   lid = c_scb[csid].lid;
  428.  
  429.   frcmd.hdr.code = RPC_FREAD_CMD;
  430.   frcmd.hdr.csid = csid;
  431.   frcmd.hdr.ssid = c_scb[csid].ssid;
  432.   frcmd.hdr.dlen = rpc_msg->hdr.dlen;
  433.   cx25_send_cmd(lid, (char *)&frcmd, sizeof(RPC_FREAD_CMD_MSG));
  434.   cx25_recv_rsp(lid, (char *)&frrsp, sizeof(RPC_FREAD_RSP_MSG));
  435.   cfifo_write(pid, (char *)&frrsp, sizeof(RPC_FREAD_RSP_MSG)); 
  436.   if(frrsp.hdr.dlen > 0)
  437.     cx25_recv_data(lid, pid, frrsp.hdr.dlen);
  438. }
  439.  
  440. cmon_fwrite(rpc_msg)
  441. RPC_MSG *rpc_msg;
  442. {
  443.   int pid, fid, lid, csid;
  444.   RPC_FWRITE_CMD_MSG fwcmd;
  445.   RPC_FWRITE_RSP_MSG fwrsp;
  446.  
  447.   pid = rpc_msg->hdr.csid;
  448.   fid = rpc_msg->hdr.ssid;
  449.   if((csid = locate_csid(pid, fid)) == -1) return;
  450.   lid = c_scb[csid].lid;
  451.  
  452.   fwcmd.hdr.code = RPC_FWRITE_CMD;
  453.   fwcmd.hdr.csid = csid;
  454.   fwcmd.hdr.ssid = c_scb[csid].ssid;
  455.   fwcmd.hdr.dlen = rpc_msg->hdr.dlen;
  456.   cx25_send_cmd(lid, (char *)&fwcmd, sizeof(RPC_FWRITE_CMD_MSG));
  457.   if(fwrsp.hdr.dlen > 0)
  458.     cx25_send_data(lid, pid, fwrsp.hdr.dlen);
  459.   cx25_recv_rsp(lid, (char *)&fwrsp, sizeof(RPC_FWRITE_RSP_MSG));
  460.   cfifo_write(pid, (char *)&fwrsp, sizeof(RPC_FWRITE_RSP_MSG)); 
  461. }
  462.  
  463. cmon_feof(rpc_msg)
  464. RPC_MSG *rpc_msg;
  465. {
  466.   int pid, fid, lid, csid;
  467.   RPC_FEOF_CMD_MSG fecmd;
  468.   RPC_FEOF_RSP_MSG fersp;
  469.  
  470.   pid = rpc_msg->hdr.csid;
  471.   fid = rpc_msg->hdr.ssid;
  472.   if((csid = locate_csid(pid, fid)) == -1) return;
  473.   lid = c_scb[csid].lid;
  474.  
  475.   fecmd.hdr.code = RPC_FEOF_CMD;
  476.   fecmd.hdr.csid = csid;
  477.   fecmd.hdr.ssid = c_scb[csid].ssid;
  478.   fecmd.hdr.dlen = 0;
  479.   cx25_send_cmd(lid, (char *)&fecmd, sizeof(RPC_FEOF_CMD_MSG));
  480.   cx25_recv_rsp(lid, (char *)&fersp, sizeof(RPC_FEOF_RSP_MSG));
  481.   cfifo_write(pid, (char *)&fersp, sizeof(RPC_FEOF_RSP_MSG)); 
  482. }
  483.  
  484.  
  485. /* utility routines */
  486.  
  487. get_server_id(sname)
  488. char *sname;
  489. {
  490.   int i; 
  491.  
  492.   for(i=0; i<c_lcb_cnt; i++)
  493.     if(!strcmp(sname, c_lcb[i].sname)) return(i);
  494.  
  495.   return(-1);
  496. }
  497.  
  498.  
  499. allocate_csid(pid, fid, lid)
  500. int pid, fid, lid;
  501. {
  502.   int csid;
  503.  
  504.   for(csid=0; csid<MAX_C_SCB; csid++)
  505.     if(c_scb[csid].state == -1) {
  506.       c_scb[csid].state = csid;
  507.       c_scb[csid].pid = pid;
  508.       c_scb[csid].fid = fid;
  509.       c_scb[csid].lid = lid;
  510.       c_scb[csid].ssid = 0;
  511.       return(csid);
  512.     }
  513.   return(-1);
  514. }
  515.  
  516.  
  517. deallocate_csid(csid)
  518. int csid;
  519. {
  520.   c_scb[csid].state = -1;
  521. }
  522.  
  523.  
  524. locate_csid(pid, fid)
  525. int pid, fid;
  526. {
  527.   int csid;
  528.  
  529.   for(csid=0; csid<MAX_C_SCB; csid++)
  530.     if((c_scb[csid].pid == pid) &&
  531.        (c_scb[csid].fid == fid)) 
  532.       return(csid);
  533.   return(-1);
  534. }
  535.  
  536.  
  537.  
  538. /* debug utilities */
  539.  
  540. dopen()
  541. {
  542.   if((cmon_io = open("/tmp/cmon_io", O_WRONLY|O_CREAT, 0666)) != -1)
  543.     debug_flag = 1;
  544.   else
  545.     debug_flag = 0;
  546. }
  547.  
  548. dclose()
  549. {
  550.   if(debug_flag)
  551.     close(cmon_io);
  552.   debug_flag = 0;
  553. }
  554.  
  555. dprintf(fmt, va_alist)
  556. char *fmt;
  557. va_dcl
  558. {
  559.   va_list ap;
  560.  
  561.   if(!debug_flag) return;
  562.   va_start(ap);
  563.   vsprintf(cmon_buf, fmt, ap);
  564.   write(cmon_io, cmon_buf, strlen(cmon_buf));
  565.   va_end(ap);
  566. }
  567.  
  568.  
  569. print_info()
  570. {
  571.     int i;
  572.  
  573.     dprintf("\nclient: %s  laddr: %s  - Total Servers: %d\n", 
  574.         cname, laddr, c_lcb_cnt);
  575.  
  576.     for(i=0; i<c_lcb_cnt; i++) 
  577.         dprintf(" server: %s  port: %d  raddr: %s\n",
  578.             c_lcb[i].sname, c_lcb[i].port, c_lcb[i].raddr);
  579. }
  580.  
  581.  
  582.  
  583.  
  584.